package com.yidu.action;


import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.mysql.fabric.xmlrpc.base.Data;
import com.yidu.common.JsonMsg;
import com.yidu.common.Pages;
import com.yidu.common.Tools;
import com.yidu.domain.ListenAuditing;
import com.yidu.domain.ListenBackstageUser;
import com.yidu.domain.ListenBranchWholesale;
import com.yidu.domain.ListenBranchWholesaleDateil;
import com.yidu.domain.ListenFinanceDetail;
import com.yidu.domain.ListenStockRecord;
import com.yidu.service.ListenAuditingService;
import com.yidu.service.ListenBranchWholesaleDateilService;
import com.yidu.service.ListenBranchWholesaleService;
import com.yidu.service.ListenFinanceDetailService;
import com.yidu.service.ListenFinanceService;
import com.yidu.service.ListenStockRecordService;
import com.yidu.service.ListenStockService;
import com.yidu.service.impl.ListenAuditingServiceImpl;

import antlr.build.Tool;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.springframework.http.HttpRequest;
import org.springframework.stereotype.Controller;

/**
 * <p>
 *  前端控制器
 * </p>
 *批发Action
 * @author 张卫民
 * @since 2018-11-27
 */
@Controller
@RequestMapping("/listenBranchWholesale")
public class ListenBranchWholesaleController {
	/**
	 * 使用注入批发service
	 */
	@Resource
	private ListenBranchWholesaleService wholesaleService;
	
	/**
	 * 使用注入批发明细service
	 */
	@Resource
	private ListenBranchWholesaleDateilService wholesaleDateService;
	
	/**
	 * 使用注入审核Service
	 */
	@Resource
	private ListenAuditingService auditingService;
	/**
	 * 使用注入库存Service
	 */
	@Resource
	private ListenStockService stockService;	
	/**
	 * 使用注入财务Service
	 */
	@Resource
	private ListenFinanceService financeService;
	/**
	 * 使用注入库存 明细Service
	 */
	@Resource
    private ListenStockRecordService stockRecordService;
	/**
	 *使用注入财务记录明细Service
	 */
	@Resource
	private ListenFinanceDetailService financeDetailService;
	/**
	 * 
	 *@title  查询所有并根据传过来的值查询所有并分页
	 * @param ListenBranchWholesale wholesale,HttpSession session
	 * @return Map maplayui
	 * @author zwm
	 * @dateTime 2019年1月14日
	 * @versions
	 */
	@RequestMapping("/selectNameAll")
	@ResponseBody
	public Map<String, Object> selectNameAll(ListenBranchWholesale wholesale,HttpSession session) throws ParseException{
		//用工具类判断获取到的开始Strin时间不为空
		if(!Tools.isEmpty(wholesale.getBwTime1())) {
			//用工具类把string类型时间转换成时间格式后面带时分秒设置进模型类里,加上时分秒
			wholesale.setBwTimea1(Tools.stringToDateTime(wholesale.getBwTime1()+" 00:00:00"));
		}
		//用工具类判断获取到结束Strin时间不为空
		if(!Tools.isEmpty(wholesale.getBwTime2())) {
			//用工具类把string类型时间转换成时间格式后面带时分秒设置进模型类里，加上时分秒
			wholesale.setBwTimea2(Tools.stringToDateTime(wholesale.getBwTime2()+" 23:59:59"));
		}
		//获取page分页工具类
		Pages pages=new Pages();
		//判断通过模型类传过来的条数和页数不为空的话
		if(wholesale.getLimit()!=null && wholesale.getPage()!=null){
			//把获取到的页数设置进工具类的当前页数
			pages.setCurPage(wholesale.getPage());
			//把获取到的行数设置进每页显示多少条数
			pages.setMaxResult(wholesale.getLimit());
		}
		
		//获取登录进来的session user对象
		ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
		
		
		//定义一个map集合
		Map<String,Object>map=new HashMap<String,Object>();
		//传过来的标题通过模型类对象获取，键为公司名称
		map.put("companyName",wholesale.getTitle());
		//获取到的开始时间放入map里，键为开始时间
		map.put("kssj", wholesale.getBwTimea1());
		//获取到的结束时间放入map里，键为结束时间
		map.put("jssj", wholesale.getBwTimea2());
		//开始的行数添加进去，键为开始行
		map.put("ksRows", pages.getFirstRows());
		//每页显示多少行数，键为结束行数
		map.put("zResult",pages.getMaxResult());
		//获取session user模型类的业务公司id
		if(user!=null) {
		//用工具类判断获取session user模型类的业务公司id不为空
		if(!Tools.isEmpty(user.getSite())) {
		//获取session user模型类的业务公司id,键为公司id
		map.put("gsId", user.getSite());
			}
		}
		
		
		
		//把map对象放进查询所有的方法里返回个集合对象
		List<ListenBranchWholesale> listt= wholesaleService.selectAll(map);
		//把map对象放进查询行数的方法里返回个int变量
		int rows = wholesaleService.selectPage(map);
		//获取一个List集合对象
		List<ListenBranchWholesale>lists=new ArrayList<>();
		//循环获取到值的集合listt
		for (ListenBranchWholesale list : listt) {
			//把批发时间通过工具类转成批发string类型的时间
			list.setBwTimeString(Tools.dateToString(list.getBwTime()));
			//把操作时间通过工具类SDf_TIME.format转成操作人String类型
			list.setOpenTimeString(Tools.SDF_TIME.format(list.getOpenTime()));
			//增加到自己获取的集合里
			lists.add(list);
		}
		//获取一个map maplayui响应到前台
		Map<String, Object>maplayui=new HashMap<String,Object>();
		//编码为零
		maplayui.put("code", 0);
		//msg为空
		maplayui.put("msg", "");
		//行数为通过查询所有行数方法返回过来的值
		maplayui.put("count",rows);
		//显示内容为自己获取的一个list集合对象
		maplayui.put("data",lists);
		//把maplayui返回到前台
		return maplayui;
		
	}
	/**
	 * 
	 *@title批发查询删除修改的方法 根据Id 【删除】
	 * @param String id
	 * @return msg
	 * @author zwm
	 * @dateTime 2018年11月28日
	 * @versions
	 */
	@RequestMapping("/deleteId")
	@ResponseBody
	public JsonMsg deleteId(String id) {
		//定义一个int类对像为零
		int ids=0;
		//判断前台传过来的id不为空的话
		if (id!=null && !"".equals(id)) {
			//就把id放进根据id删除的方法里用定义的值接收
			ids = wholesaleService.deleteId(id);
		}
		System.out.println("sssssssssssss"+ids);
		//获取Msg工具类对象
		JsonMsg msg=new JsonMsg();
		//判断int接收的值不等于零
		if(ids!=0) {
			//datas为1设置进去
			msg.setDatas(1);
			//msg为删除成功设置进去
			msg.setMsg("删除成功");
		}else {
			//datas为零设置进去
			msg.setDatas(0);
			//msg为删除失败设置进去
			msg.setMsg("删除失败");
		}
		//返回msg
		return msg;
	}
	/**
	 * 
	 *@title增加修改的方法【有则增加修改】
	 * @param ListenBranchWholesale wholes
	 * @return 无返回值
	 * @author zwm
	 * @throws ParseException 
	 * @dateTime 2018年11月29日
	 * @versions
	 */
	@RequestMapping("/addUpdate")
	public void addUpdate(ListenBranchWholesale wholes) throws ParseException {
		System.err.println("增加修改的方法进来了。。。。。。。。。。。"+wholes.getBwId()+"sdsd");
		//如果通过类对象获取到的批发String时间不为空的话
		if(wholes.getBwTimeString()!=null) {
			//就把批发时间转换成时间格式放进模型类，以批发data类型参数接收
			wholes.setBwTime(Tools.stringToDate(wholes.getBwTimeString()));
		}
		//获取date对象
		Date date=new Date();
		System.out.println("增加修改的方法得到的时间： "+date);
		//把date对象设置进放进操作时间
		wholes.setOpenTime(date);
		//根据类对象获取批发id不为空判断
		if(wholes.getBwId()!=null && !"".equals(wholes.getBwId())) {
			System.err.println("修改的方法进来了。。。。。");
			//调用根据id修改所有的方法返回一个int参数
			int idUpdate = wholesaleService.idUpdateAll(wholes);
			System.out.println("修改返回的值   :"+idUpdate);
		}else{
			System.err.println("增加的方法进来了。。。。。");
			//用工具类获取到uuid设置成30位设置到批发id里
			wholes.setBwId(Tools.getRandomString(30));
			//调用增加的方法返回int参数接收
			int add = wholesaleService.add(wholes);
			System.out.println("增加返回的值        :"+add);
		}
		
	}
	
	/**
	 * 
	 *@title 根据id查询所有并返回类对象
	 * @param String id
	 * @return ListenBranchWholesale wholes
	 * @author zwm
	 * @dateTime 2018年11月29日
	 * @versions
	 */
	@RequestMapping("/idQueryAll")
	@ResponseBody
	public ListenBranchWholesale idQueryAll(String id) {
		System.out.println("进来了 sdsdsdsdsdsdsds");
		//调用根据id查询所有返回类对象的方法
		ListenBranchWholesale wholes = wholesaleService.idQueryAll(id);
		//用工具类把获取到的批发时间转换成string类型设置进模型类对象批发string类型接收
		wholes.setBwTimeString(Tools.dateToString(wholes.getBwTime()));
		//返回根据id查询所有的方法
		return wholes;
		
	}
	/**
	 * 
	 *@title 增加批发的数据信息
	 * @param String html,String hjjg,String hjsls,HttpSession session
	 * @return JsonMsg msg
	 * @author zwm
	 * @dateTime 2018年12月10日
	 * @versions
	 */
	@RequestMapping("/addWhole")
	@ResponseBody
	public JsonMsg addWhole(String html,String hjjg,String hjsls,HttpSession session) {
		System.err.println(" 数据信息:  "+html+"      合计价格:"+hjjg+" 合计数量 :"+hjsls);
		//把html以#分割用string数组接收
		String[] split = html.split("#");
		System.out.println(split);
		//获取批发模型类对象
		ListenBranchWholesale wholesale=new ListenBranchWholesale();
		
		//获取用户Session，用用户模型类接收
		ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
		//批发增加方法返回接收的变量名
		int pfadd=0;
		//定义批发明细增加方法返回接收的int变量名
		int add=0;
		//循环数组根据数组的长度
		for (int i = 0; i < split.length; i++) {
			 //以,分割，使用split2数组接收
			 String[] split2 = split[i].split(",");
			 //获取数组里的值0为公司名
			 String companyName = split2[0];
			 System.out.println("公司名称 ："+companyName);
			 //获取数组里的值1为乐器类型名称
			 String mtName = split2[1];
			 System.out.println("乐器类型名称 :"+mtName);
			 //获取数组里的值2为乐器名称
			 String muName = split2[2];
			 System.out.println("乐器名称  :"+muName);
			 //获取数组里的值3为规格muSpecifications
			 String muSpecifications = split2[3];
			 System.out.println("规格  :"+muSpecifications);
			 //获取数组里的值4为零售价muPrice
			 String muPrice = split2[4];
			 System.out.println("建议零售价  :"+muPrice);
			 //获取数组里的值12为小计muNumber
			 String muNumber = split2[12];
			 System.out.println("小计  :"+muNumber);
			 //获取数组里的值13为批发价 muPrices
			 String muPrices = split2[13];
			 System.out.println("批发价  :"+muPrices);
			 //获取数组里的值14为乐器id muId
			 String muId = split2[14];
			 System.out.println("乐器id  :"+muId);
			 //获取数组里的值15为公司id companyId
			 String companyId = split2[15];
			 System.out.println("公司id  :"+companyId);
			 //获取数组里的值16为乐器类型id mtId
			 String mtId = split2[16];
			 System.out.println("类型id  :"+mtId);
			 //获取数组里的值17为批发数量 muPricess
			 String muPricess = split2[17];
			 System.out.println("批发数量  :"+muPricess);
			//判断运行第一次的时候 增加批发
			if(i==0) {
				//增加批发的id 用工具类获取一个30位的id
				String uuid=Tools.getRandomString(30);
				//把获取到的uuid设置进批发模型类里
				wholesale.setBwId(uuid);
				//把获取到的公司id设置进模型类的公司id里
				wholesale.setCompanyId(companyId);  
				//获取date对象
				Date data=new Date();
				//把data设置进批发模型类批发时间里
				wholesale.setBwTime(data);
				//把获取到的hjjg强转成Double类型在转成bigDecimal类型设置进销售总金额里
				wholesale.setBwPrice(BigDecimal.valueOf(Double.valueOf(hjjg)));
				//把获取到的hjsls转成integer类型设置进批发模型类的分店销售总数量里
				wholesale.setBwNumber(Integer.valueOf(hjsls));
				//增加是否可用，默认为‘1’
				wholesale.setIsva("1");
				//操作时间设置data进去
				wholesale.setOpenTime(data);
				//判断session user不为空
				if(user!=null){
				//使用session user取到操作人名称设置进批发操作人里
				wholesale.setOper(user.getBuName());
				}
				//设置状态默认审核状态为1
				wholesale.setBwStatus(1);
				//调用批发数据增加的方法使用定义的int变量接收
				 pfadd = wholesaleService.add(wholesale);
			}
			//获取批发明细模型类对象
			ListenBranchWholesaleDateil wholesdate=new ListenBranchWholesaleDateil();
			//用工具类获取30位随机数做为mxuuid
			String mxuuid=Tools.getRandomString(30);
			//把获取到的mxuuid设置进批发明细id里
			wholesdate.setBwdId(mxuuid);
			//把增加进批发模型类的批发id，取出放进明细的外键批发id里
			wholesdate.setBwId(wholesale.getBwId());
			//把获取到的乐器id放进批发明细外键乐器的id里
			 wholesdate.setMuId(muId);
			//把获取到的乐器名称放进批发明细乐器的名称里
			 wholesdate.setMuName(muName);
			//把获取到的类型名称放进批发明细的乐器类型名称里
			 wholesdate.setMtName(mtName);
			 //把获取到的批发数量放进批发明细乐器批发数量里
			 wholesdate.setMuNumber(Integer.valueOf(muPricess));
			 //把获取到的批发价格强转成Double类型在转成bigDecimal类型放进批发明细乐器批发价里
			 wholesdate.setTradePrice(BigDecimal.valueOf(Double.valueOf(muPrices)));
			 //把获取到的小计强转成Double类型在转成bigDecimal类型放进批发明细乐器小计里
			 wholesdate.setSubtotal(BigDecimal.valueOf(Double.valueOf(muNumber)));
			 //批发明细是否有效默认为1
			 wholesdate.setIsva("1");
			 //获取date对象
			 Date dates=new Date();
			 //把dates设置进操作时间里
			 wholesdate.setOpenTime(dates);
			 //判断Session对象 user 不等于null
			 if(user!=null) {
			 //用user获取用户名称设置进操作人里
			 wholesdate.setOper(user.getBuName());
			 }
			 //调用批发明细增加的方法，放入批发明细对象用定义好的int批发明细参数接收
			 add = wholesaleDateService.add(wholesdate);
			 
		}
		//获取msg工具类
		JsonMsg msg=new JsonMsg();
		//判断批发增加返回的参数和明细增加返回的的参数大于0
		if(pfadd>0 && add>0) {
			//设置data为1
			msg.setDatas(1);
			//设置msg为操作成功
			msg.setMsg("操作成功");
		}else {
			//设置data为0
			msg.setDatas(0);
			//设置msg为操作失败
			msg.setMsg("操作失败");
		}
		//返回msg对象
		return msg;
	}
	/**
	 * 
	 *@title 审核查询所有的方法
	 * @param ListenBranchWholesale wholesale,Integer page,Integer limit,HttpSession session
	 * @return Map<String, Object> layuiMap
	 * @author zwm
	 * @throws ParseException 
	 * @dateTime 2018年12月18日
	 * @versions
	 */
	@RequestMapping("/auditSelect")
	@ResponseBody
	public Map<String, Object>auditSelect(ListenBranchWholesale wholesale,Integer page,Integer limit,HttpSession session) throws ParseException{
		System.err.println("对象值   编号id ："+wholesale.getBwId()+" 公司名称  :"+wholesale.getCompanyName()+" 批发开始时间 : "+wholesale.getBwTime1()+" 批发结束时间 ："+wholesale.getBwTime2());
		System.err.println("开始页数："+page+"   总行数："+limit);
		//获取分页工具类对象
		Pages pages=new Pages();
		//判断获取到的页数不为空和行数不为空
		if(page!=null && limit!=null) {
			//把获取到的页面设置进当前页数
			pages.setCurPage(page);
			//把获取到的行数设置进每页显示行数
			pages.setMaxResult(limit);
		}
		//用工具类判断传过来的String类型的开始时间不为空
		if(!Tools.isEmpty(wholesale.getBwTime1())) {
			//用工具类转换Date带时分秒设置进模型类时间1
			wholesale.setBwTimea1(Tools.stringToDateTime(wholesale.getBwTime1()+" 00:00:00"));
		}
		//用工具类判断传过来的String类型的结束时间不为空
		if(!Tools.isEmpty(wholesale.getBwTime2())) {
			//用工具类转换Date带时分秒设置进模型类时间2
			wholesale.setBwTimea2(Tools.stringToDateTime(wholesale.getBwTime2()+" 23:59:59"));
		}
		//获取登录进来的session user对象
		ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
				
		//获取一个map对象
		Map<String, Object>map=new HashMap<>();
		//把批发id从模型从模型类取出放进map，键为bwId
		map.put("bwId", wholesale.getBwId());
		//把公司名称从模型类取出放进map，键为companyName
		map.put("companyName", wholesale.getCompanyName());
		//把批发开始时间从模型类取出放进map，键为bwTime1
		map.put("bwTime1", wholesale.getBwTimea1());
		//把批发结束时间从模型类取出放进map，键为bwTime2
		map.put("bwTime2", wholesale.getBwTimea2());
		//把开始行数从pages工具类取出放进map，键为kshs
		map.put("kshs", pages.getFirstRows());
		//把一页多少行从pages工具类取出放进map，键为jshs
		map.put("jshs", pages.getMaxResult());
		//获取session user模型类的业务公司id
		if(user!=null) {
		//用工具类判断获取session user模型类的业务公司id不为空
		if(!Tools.isEmpty(user.getSite())) {
		//获取session user模型类的业务公司id,键为公司id
		map.put("gsId", user.getSite());
			}
		}
		
		//调用审核查询的方法返回一个list集合放入map返回集合
		List<ListenBranchWholesale> list = wholesaleService.auditSelect(map);
		//自己获取一个集合为listss
		List<ListenBranchWholesale> listss = new ArrayList<>();
		//循环list集合
		for (ListenBranchWholesale lists : list) {
			//用工具类SDF_TIME.format把date类型转换成string
			lists.setBwTimeString(Tools.SDF_TIME.format(lists.getBwTime()));
			//放入自己定义的集合中
			listss.add(lists);
		}
		
		//调用 审核行数的方法放入map 返回int类型 rows接受
		int rows = wholesaleService.auditCount(map);
		//获取一个map对象layuiMap
		Map<String, Object>layuiMap=new HashMap<>();
		//设置code编码为零
		layuiMap.put("code",0);
		//设置msg为零
		layuiMap.put("msg","");
		//设置行数为获取到的rows
		layuiMap.put("count",rows);
		//设置内容为获取到的集合
		layuiMap.put("data",listss);
		//返回layuiMap
		return layuiMap;
	}
	/**
	 * 
	 *@title 批发财务审核修改批发审核状态添加审核的方法
	 * @param ListenBranchWholesale wholesale，HttpSession session
	 * @return JsonMsg
	 * @author zwm
	 * @dateTime 2018年12月19日
	 * @versions
	 */
	@RequestMapping("/financeAudit")
	@ResponseBody
	public JsonMsg financeAudit(ListenBranchWholesale wholesale,HttpSession session) {
		System.err.println(" 批发财务审核  审核前台获取到的批发id ："+wholesale.getBwId()+"  批发审核状态 string类型："+wholesale.getBwStatusString()+" 批发审核意见 ："+wholesale.getAuditingExplain());
		//调用工具类判断传过来的字符串状态不为空
		if(!Tools.isEmpty(wholesale.getBwStatusString())) {
			//把String类型转换成intger类型设置进模型类
			wholesale.setBwStatus(Integer.valueOf(wholesale.getBwStatusString()));
		}
		//获取用户session user模型类对象接收
		ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
		//获取JsonMsg工具类
		JsonMsg msg=new JsonMsg();
		//根据批发id查询明细放入模型类对象 返回批发集合
		List<ListenBranchWholesale> bwIdSelectMx = wholesaleService.bwIdSelectMx(wholesale);
		//定义修改接受的变量
		int update=0;
		//循环返回的集合
		for (ListenBranchWholesale listenBranchWholesale : bwIdSelectMx) {
			System.err.println(" 返回集合的方法进来了。 ： "+listenBranchWholesale.getMuNumber());
			//获取批发类对象
			ListenBranchWholesale wholesales=new ListenBranchWholesale();
			//通过模型类对象把页面上的批发id设置进去
			wholesales.setBwId(wholesale.getBwId());
			//把循环出来的乐器id设置进去
			wholesales.setMuId(listenBranchWholesale.getMuId());
			//调用根据批发id乐器id查询库存放入模型类对象，返回类对象的方法
			ListenBranchWholesale bwidmuIdKc = wholesaleService.bwidmuIdKc(wholesales);
			System.err.println(" 返回集合的方法进来了。乐器数量 ： "+listenBranchWholesale.getMuNumber()+" 库存数量 : "+bwidmuIdKc.getStockNumber());
			//判断批发出去的乐器数量大于库存数量
			if(listenBranchWholesale.getMuNumber()>bwidmuIdKc.getStockNumber()){
				//datas为零
				msg.setDatas(0);
				//msg为库存不足
				msg.setMsg("库存不足");
				//返回msg
				return msg;
			}else {
				//调用根据id修改放入类对象返回int的方法用自己定义的参数接收
				 update = wholesaleService.idUpdate(wholesale);
			}		
		}
		//获取审核模型类对象
		ListenAuditing  auditing=new ListenAuditing();
		//用工具类定义一个三十位的字符串uuid设置进审核id
		auditing.setAuditingId(Tools.getRandomString(30));
		//用模型类获取批发id放进审核模型类业务id里
		auditing.setVocationalWorkId(wholesale.getBwId());
		//用模型类获取状态string类型转换成integer放入审核模型类状态
		auditing.setAuditingStatus(Integer.valueOf(wholesale.getBwStatusString()));
		//用模型类对象获取审核意见设置审核意见里
		auditing.setAuditingExplain(wholesale.getAuditingExplain());
		//获取当前时间Date对象
		Date date=new Date();
		//把date放进审核对象时间里
		auditing.setAuditingTime(date);
		//判断获取到的session对象user不等于空
		if(user!=null) {
		//从user里获取用户名放入审核人里
		auditing.setAuditingPeople(user.getBuName());
		}
		/*auditing.setRemarks("");*/
		//审核状态设置默认为1
		auditing.setIsva(1);
		//操作时间获取默认为date
		auditing.setOpenTime(date);
		/*auditing.setOper("默认操作人");*/
		//审核排序默认为‘1’
		auditing.setSort("1");
		System.out.println();
		//调用批发增加，放入审核对象返回int rows接收的方法
		int rows = auditingService.pfInsert(auditing);
		System.out.println(" 修改状态返回的值 :"+update+"  增加审核记录返回的值："+rows);
		//判断修改状态方法返回的值和增加审核记录的值大于零
		if(update>0 && rows>0) {
			//datas为1
			msg.setDatas(1);
			//msg为操作成功
			msg.setMsg("操作成功");
		}else {
			//datas为0
			msg.setDatas(0);
			//msg为操作失败
			msg.setMsg("操作失败");
		}
		//返回msg对象
		return msg;
	}
	/**
	 * 
	 *@title 批发财务审核修改批发审核状态添加审核失败的方法
	 * @param ListenBranchWholesale wholesale
	 * @return JsonMsg
	 * @author zwm
	 * @dateTime 2018年12月19日
	 * @versions
	 */
	@RequestMapping("/financeAudits")
	@ResponseBody
	public JsonMsg financeAudits(ListenBranchWholesale wholesale,HttpSession session) {
		System.err.println(" 批发财务审核  审核前台获取到的批发id ："+wholesale.getBwId()+"  批发审核状态 string类型："+wholesale.getBwStatusString()+" 批发审核意见 ："+wholesale.getAuditingExplain());
		//调用工具类判断传过来的字符串状态不为空
		if(!Tools.isEmpty(wholesale.getBwStatusString())) {
			//把String类型转换成intger类型设置进模型类对象里
			wholesale.setBwStatus(Integer.valueOf(wholesale.getBwStatusString()));
		}
		//获取用户session user模型类对象接收
		ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
		//调用根据id修改，放入模型类对象返回int update接收
		int update = wholesaleService.idUpdate(wholesale);
		// 获取审核模型类对象
		ListenAuditing  auditing=new ListenAuditing();
		//用工具类定义一个三十位的字符串uuid设置进审核id
		auditing.setAuditingId(Tools.getRandomString(30));
		//用模型类获取批发id放进审核模型类业务id里
		auditing.setVocationalWorkId(wholesale.getBwId());
		//用模型类获取状态string类型转换成integer放入审核模型类状态
		auditing.setAuditingStatus(Integer.valueOf(wholesale.getBwStatusString()));
		//用模型类对象获取审核意见设置审核意见里
		auditing.setAuditingExplain(wholesale.getAuditingExplain());
		//获取当前时间date对象
		Date date=new Date();
		//把date放进审核对象时间里
		auditing.setAuditingTime(date);
		//判断获取的session user对象不等于空
		if(user!=null) {
		//从user里获取用户名放入审核人里
		auditing.setAuditingPeople(user.getBuName());
		}
		/*auditing.setRemarks("");*/
		//审核状态设置默认为1
		auditing.setIsva(1);
		//操作时间获取默认为date
		auditing.setOpenTime(date);
		/*auditing.setOper("默认操作人");*/
		//审核排序默认为‘1’
		auditing.setSort("1");
		System.out.println();
		
		
		
		
		//调用审核service 批发增加放入审核对象返回int rows的方法
		int rows = auditingService.pfInsert(auditing);
		System.out.println(" 修改状态返回的值 :"+update+"  增加审核记录返回的值："+rows);
		//获取JsonMsg工具类
		JsonMsg msg=new JsonMsg();
		//判断修改状态方法返回的值和增加审核记录的值大于零
		if(update>0 && rows>0) {
			//设置datas为1
			msg.setDatas(1);
			//设置msg为操作成功
			msg.setMsg("操作成功");
		}else {
			//设置datas为零
			msg.setDatas(0);
			//设置msg为操作失败
			msg.setMsg("操作失败");
		}
		//返回msg对象
		return msg;
	}
	/**
	 *@title 总经理审核查询所有根据条件分页的方法
	 * @param ListenBranchWholesale wholesale,Integer page,Integer limit,HttpSession session
	 * @return Map<String, Object> layuiMap
	 * @author zwm
	 * @dateTime 2018年12月20日
	 * @versions
	 */
	@RequestMapping("/zjlAuditSelect")
	@ResponseBody
	public Map<String, Object>zjlAuditSelect(ListenBranchWholesale wholesale,Integer page,Integer limit,HttpSession session) throws ParseException{
		System.err.println("对象值   编号id ："+wholesale.getBwId()+" 公司名称  :"+wholesale.getCompanyName()+" 批发开始时间 : "+wholesale.getBwTime1()+" 批发结束时间 ："+wholesale.getBwTime2());
		System.err.println("开始页数："+page+"   总行数："+limit);
		//获取分页工具类对象
		Pages pages=new Pages();
		//判断获取到的页数不等于空 和获取的行数不等于空
		if(page!=null && limit!=null) {
			//把获取到的页数设置进工具类的开始行页里
			pages.setCurPage(page);
			//把获取到的页数设置进工具类的一页多少行数里
			pages.setMaxResult(limit);
		}
		//用工具类判断传过来的String类型的开始时间不为空1
		if(!Tools.isEmpty(wholesale.getBwTime1())) {
			//用工具类把String类型转换Date加上时分秒
			wholesale.setBwTimea1(Tools.stringToDateTime(wholesale.getBwTime1()+" 00:00:00"));
		}
		//用工具类判断传过来的String类型的结束时间不为空2
		if(!Tools.isEmpty(wholesale.getBwTime2())) {
			//用工具类把String类型转换Date加上时分秒
			wholesale.setBwTimea2(Tools.stringToDateTime(wholesale.getBwTime2()+" 23:59:59"));
		}
		//获取登录进来的session user对象
		ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
		//获取map对象
		Map<String, Object>map=new HashMap<>();
		//把批发id从模型从模型类取出放进map，键为bwId
		map.put("bwId", wholesale.getBwId());
		//把公司名称从模型类取出放进map，键为companyName
		map.put("companyName", wholesale.getCompanyName());
		//把批发开始时间从模型类取出放进map，键为bwTime1
		map.put("bwTime1", wholesale.getBwTimea1());
		//把批发结束时间从模型类取出放进map，键为bwTime2
		map.put("bwTime2", wholesale.getBwTimea2());
		//把批发开始行数从page工具类取出放进map，键为kshs
		map.put("kshs", pages.getFirstRows());
		//把批发结束行数从page工具类取出放进map，键为jshs
		map.put("jshs", pages.getMaxResult());//结束行数
		//获取session user模型类的业务公司id
		if(user!=null) {
		//用工具类判断获取session user模型类的业务公司id不为空
		if(!Tools.isEmpty(user.getSite())) {
		//获取session user模型类的业务公司id,键为公司id
		map.put("gsId", user.getSite());
			}
		}
		
		//调用总经理审核查询放进map的返回list集合的方法
		List<ListenBranchWholesale> list = wholesaleService.zjlAuditSelect(map);
		//自己定义一个批发list集合
		List<ListenBranchWholesale> listss = new ArrayList<>();
		//循环查询返回的集合
		for (ListenBranchWholesale lists : list) {
			//用工具类SDF_TIME.format把date类型批发时间转换成string
			lists.setBwTimeString(Tools.SDF_TIME.format(lists.getBwTime()));
			//把循环的集合增加到自己定义的集合里
			listss.add(lists);
		}
		
		//调用总经理行数放入map返回int rows的方法
		int rows = wholesaleService.zjlAuditCount(map);
		//获取一个map类对象layuiMap
		Map<String, Object>layuiMap=new HashMap<>();
		//设置code编码为零
		layuiMap.put("code",0);
		//设置msg为空
		layuiMap.put("msg","");
		//设置行数为返回的int rows
		layuiMap.put("count",rows);
		//设置内容为自己定义的集合 listss
		layuiMap.put("data",listss);
		//返回layuiMap
		return layuiMap;
	}
	/**
	 * 
	 *@title 总经理审核修改批发审核状态，添加审核记录
	 * @param ListenBranchWholesale wholesale,HttpSession session
	 * @return JsonMsg msg
	 * @author zwm
	 * @dateTime 2018年12月20日
	 * @versions
	 */
	@RequestMapping("/zjlAudit")
	@ResponseBody
	public JsonMsg zjlAudit(ListenBranchWholesale wholesale,HttpSession session) {
		System.err.println(" 批发财务审核  审核前台获取到的批发id ："+wholesale.getBwId()+"  批发审核状态 string类型："+wholesale.getBwStatusString()+" 批发审核意见 ："+wholesale.getAuditingExplain());
		//调用工具类判断传过来的字符串状态不为空
		if(!Tools.isEmpty(wholesale.getBwStatusString())) {
			//把String类型转换成intger类型设置进模型类对象里
			wholesale.setBwStatus(Integer.valueOf(wholesale.getBwStatusString()));
		}
		//获取用户session user模型类对象接收
		ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
		//调用根据id修改，放入模型类对象返回int update接收
		int update = wholesaleService.idUpdate(wholesale);
		// 获取审核模型类对象
		ListenAuditing  auditing=new ListenAuditing();
		//用工具类定义一个三十位的字符串uuid设置进审核id
		auditing.setAuditingId(Tools.getRandomString(30));
		//用模型类获取批发id放进审核模型类业务id里
		auditing.setVocationalWorkId(wholesale.getBwId());
		//用模型类获取状态string类型转换成integer放入审核模型类状态
		auditing.setAuditingStatus(Integer.valueOf(wholesale.getBwStatusString()));
		//用模型类对象获取审核意见设置审核意见里
		auditing.setAuditingExplain(wholesale.getAuditingExplain());
		//获取当前时间对象date
		Date date=new Date();
		//把date放进审核对象时间里
		auditing.setAuditingTime(date);
		//判断获取到的session对象user不等于空
		if(user!=null) {
			//从user里获取用户名放入审核人里
			auditing.setAuditingPeople(user.getBuName());
		}
		/*auditing.setRemarks("");*/
		//审核状态设置默认为1
		auditing.setIsva(1);
		//审核操作时间默认为date对象
		auditing.setOpenTime(date);
		/*auditing.setOper("默认操作人");*/
		//审核排序默认为‘1’
		auditing.setSort("1");
		System.out.println();
		
		//调用审核service 批发增加 放审核对象返回int rows的方法
		int rows = auditingService.pfInsert(auditing);
		System.err.println(" 修改状态返回的值 :"+update+"  增加审核记录返回的值："+rows);
		//获取JsonMsg工具类
		JsonMsg msg=new JsonMsg();
		//判断修改状态方法返回的值和增加审核记录的值大于零
		if(update>0 && rows>0) {
			//datas为1
			msg.setDatas(1);
			//msg为操作成功
			msg.setMsg("操作成功");
		}else {
			//datas为0
			msg.setDatas(0);
			//msg为操作失败
			msg.setMsg("操作失败");
		}
		//返回msg对象
		return msg;
	}
	
	/**
	 * 
	 *@title 总经理审核 不通过的时候修改批发审核状态
	 * @param ListenBranchWholesale wholesale
	 * @return JsonMsg
	 * @author zwm
	 * @dateTime 2018年12月20日
	 * @versions
	 */
	@RequestMapping("/zjlAuditNot")
	@ResponseBody
	public JsonMsg zjlAuditNot(ListenBranchWholesale wholesale,HttpSession session) {
		System.err.println(" 批发财务审核  审核前台获取到的批发id ："+wholesale.getBwId()+"  批发审核状态 string类型："+wholesale.getBwStatusString()+" 批发审核意见 ："+wholesale.getAuditingExplain());
		//调用工具类判断传过来的字符串状态不为空
		if(!Tools.isEmpty(wholesale.getBwStatusString())) {
			//把状态String类型转换成intger类型设置进对象状态里
			wholesale.setBwStatus(Integer.valueOf(wholesale.getBwStatusString()));
		}
		//获取登录session user模型类对象接收
		ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
		//调用根据id修改审核状态返回int的方法
		int update = wholesaleService.idUpdate(wholesale);
		// 获取审核模型类对象
		ListenAuditing  auditing=new ListenAuditing();
		//用工具类获取字符串30的uuid设置进审核id里
		auditing.setAuditingId(Tools.getRandomString(30));
		//用模型类获取批发id设置进审核业务id里
		auditing.setVocationalWorkId(wholesale.getBwId());
		//用模型类获取状态string类型转换成integer放入审核模型类状态
		auditing.setAuditingStatus(Integer.valueOf(wholesale.getBwStatusString()));
		//用模型类对象获取审核意见设置审核意见里
		auditing.setAuditingExplain(wholesale.getAuditingExplain());
		//获取当前时间对象date
		Date date=new Date();
		//把获取到的data对象设置进审核时间里
		auditing.setAuditingTime(date);
		//判断获取到的session user对象不等于空
		if(user!=null) {
		//用user对象获取操作人名称设置进审核人里
		auditing.setAuditingPeople(user.getBuName());
		}
	/*	auditing.setRemarks("");*/
		//审核状态默认为1
		auditing.setIsva(1);
		//操作时间默认为date
		auditing.setOpenTime(date);
		/*auditing.setOper("默认操作人");*/
		//排序默认为1
		auditing.setSort("1");
		
		
		//调用审核service 批发增加放入审核对象的放法
		int rows = auditingService.pfInsert(auditing);
		System.out.println(" 修改状态返回的值 :"+update+"  增加审核记录返回的值："+rows);
		//获取JsonMsg工具类
		JsonMsg msg=new JsonMsg();
		//判断修改状态方法返回的值和增加审核记录的值大于零
		if(update>0 && rows>0) {
			//datas为1
			msg.setDatas(1);
			//msg为操作成功
			msg.setMsg("操作成功");
		}else {
			//datas为0
			msg.setDatas(0);
			//msg为操作失败
			msg.setMsg("操作失败");
		}
		//返回msg对象
		return msg;
	}
	/**
	 * 
	 *@title 根据id查询审核的方法 并分页
	 * @param ListenBranchWholesale wholesale
	 * @return  Map<String, Object> mapLayui
	 * @author zwm
	 * @dateTime 2018年12月20日
	 * @versions                                                
	 */
	@RequestMapping("/idSelectAudit")
	@ResponseBody
	public Map<String, Object>idSelectAudit(ListenBranchWholesale wholesale){
		System.err.println("获取批发id :"+ wholesale.getBwId()+"  获取开始页数 :"+wholesale.getPage()+"  获取一页行数  :"+wholesale.getLimit());
		//获取分页工具类对象
		Pages pages=new Pages();
		//判断用模型类对象获取页数和行数不等于空
		if(wholesale.getPage()!=null && wholesale.getLimit()!=null) {
			//把获取到的页数设置进分页工具类对象当前页数里
			pages.setCurPage(wholesale.getPage());
			//把获取到的行数设置进分页工具类一页多少行里
			pages.setMaxResult(wholesale.getLimit());
		}
		//获取一个map对象
		Map<String, Object>map=new HashMap<>();
		//用类对象获取批发id，键为bwId
		map.put("bwId",wholesale.getBwId());
		//用分页工具类获取开始行数，键为kshs
		map.put("kshs",pages.getFirstRows());
		//用分页工具类获取一页多少行，键为jshs
		map.put("jshs", pages.getMaxResult());
		//使用审核service调用根据 id查询放入map返回list集合的方法
		List<ListenAuditing> list = auditingService.idSelect(map);
		//使用审核sercice调用 id行数放入map返回int rows的方法
		int rows = auditingService.idCount(map);
		//循环返回的list
		for (ListenAuditing lists : list) {
			//用工具类把循环的审核date时间转成string时间设置进审核string时间里
			lists.setAuditingTimeString(Tools.getTimeStr(lists.getAuditingTime()));
			//用工具类把循环出的date操作时间转换成String类型放入list审核操作string时间里
			lists.setOpenTimeString(Tools.getTimeStr(lists.getOpenTime()));
			//判断循环出的审核状态等于2
			if(lists.getAuditingStatus()==2) {
			//就把审核状态string设置成‘财务审核通过‘设置进去
			lists.setStatusString("财务审核通过");
			}
			//判断循环出的审核状态等于3
			if(lists.getAuditingStatus()==3) {
			//就把审核状态string设置成‘财务审核通过‘设置进去
			lists.setStatusString("总经理审核通过");
			}
			//判断循环出的审核状态等于3
			if(lists.getAuditingStatus()==4) {
			//就把审核状态string设置成‘审核不通过’设置进去
			lists.setStatusString("审核不通过");
			}
		}
		//获取map对象mapLayui
		Map<String, Object>mapLayui=new HashMap<>();
		//code编码为0
		mapLayui.put("code", 0);
		//msg为空
		mapLayui.put("msg", "");
		//行数为获取的值rows
		mapLayui.put("count",rows);
		//内容为返回的list集合
		mapLayui.put("data", list);
		//返回mapLayuid
		return mapLayui;
	}
	
	/**
	 * 
	 *@title 总经理审核修改批发审核状态，添加审核记录，增加财务减少库存
	 * @param ListenBranchWholesale wholesale,HttpSession session
	 * @return JsonMsg
	 * @author zwm
	 * @dateTime 2018年12月23日
	 * @versions
	 */
	@RequestMapping("/inventoryFinance")
	@ResponseBody
	public JsonMsg inventoryFinance(ListenBranchWholesale wholesale,HttpSession session) {
		System.err.println("    总经理审核修改批发审核状态，添加审核记录，增加财务减少库存的方法进来了。。。。。批发的id :"+wholesale.getBwId());
		//乐器id修改返回接收的int变量名
		int muIdUpdate=0;
		//id修改财务返回接收的int变量名
		int idUpdateCw=0;
		//获取登录session user模型类对象接收
		ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
		//用工具类方法判断获取前台的批发id不为空
		if(!Tools.isEmpty(wholesale.getBwId())) {
			//调用根据批发id查询放入类对象返回list集合的方法
			List<ListenBranchWholesale> bwIdselect = wholesaleService.bwIdselect(wholesale);
			//循环返回的集合
			for (ListenBranchWholesale bwIdselects: bwIdselect) {
				System.err.println(" 跟据批发id查询明细得到的值 ："+bwIdselects.getBwdId()+" ,"+bwIdselects.getMuId()+" ,"+bwIdselects.getMuName()+" ,"+bwIdselects.getMtName()+" ,数量:"+bwIdselects.getMuNumber()+" ,"+bwIdselects.getTradePrice()+" ,"+bwIdselects.getSubtotal()+" 公司id+"+bwIdselects.getCompanyId());
				//获取批发类对象
				ListenBranchWholesale wholeOne=new ListenBranchWholesale();
				//用工具类判断循环出的公司id不为空
				if(!Tools.isEmpty(bwIdselects.getCompanyId())) {
					//就把获取到的公司id设置进模型类里
					wholeOne.setCompanyId(bwIdselects.getCompanyId());
				}
				//用工具类判断循环出的乐器id不为空
				if(!Tools.isEmpty(bwIdselects.getMuId())) {
					//就把循环出的乐器id设置进模型类对象里
					wholeOne.setMuId(bwIdselects.getMuId());
				}
				//用工具类判断循环出的批发id不为空的
				if(!Tools.isEmpty(bwIdselects.getBwId())) {
					//就把循环出的批发id取出设置进模型类对象里
					wholeOne.setBwId(bwIdselects.getBwId());
				}
				//调根据批发id查询cs放入自己定义的批发类对象返回list集合的方法
				List<ListenBranchWholesale> bwIdseleCs = wholesaleService.bwIdseleCs(wholeOne);
				//循环集合
				for (ListenBranchWholesale listenBranchWholesale : bwIdseleCs) {
					System.err.println(" 库存的数量 :"+listenBranchWholesale.getStockNumber()+"  乐器的id :"+listenBranchWholesale.getMuId()+" 库存id: "+listenBranchWholesale.getStockId());
					//用工具类判断循环出的乐器id不为空
					if(!Tools.isEmpty(listenBranchWholesale.getMuId())) {
						//定义一个map对象
						Map<String, Object>map=new HashMap<>();
						//把循环获取到的乐器数量设置进map键为kcSl
						map.put("kcSl",bwIdselects.getMuNumber());
						//把循环取到的乐器id设置进map键为muId
						map.put("muId",bwIdselects.getMuId());
						//把循环出的公司id设置进map键为gsId
						map.put("gsId", bwIdselects.getCompanyId());
						//调用根据乐器id修改返回int的方法
						 muIdUpdate = stockService.muIdUpdate(map);
						System.err.println("调用根据乐器id修改库存数量返回的int值"+muIdUpdate);
					}
						//调用工具类判断循环出的库存id不为空的
						if(!Tools.isEmpty(listenBranchWholesale.getStockId())) {
							System.err.println(" 进入增加库存明细的方法    获取得值 :"+listenBranchWholesale.getStockId());
						//用工具类获取一个三十位的随机uuid 
						String uuid = Tools.getRandomString(30);
						//获取库存明细模型类对象
						ListenStockRecord kcmx=new ListenStockRecord();
						//把用工具类获取到的id设置进去
						kcmx.setSrId(uuid);
						//把循环出的库存id设置进库存明细模型类的库存id里
						kcmx.setStockId(listenBranchWholesale.getStockId());
						//把循环出的乐器名称设置进库存明细的乐器名称里
						kcmx.setMuName(bwIdselects.getMuName());
						//获取当前时间Date对象
						Date date = new Date();
						//把date对象设置进明细时间里
						kcmx.setSrTime(date);
						//把循环出的乐器数量设置进明细数量里
						kcmx.setSrNumber(bwIdselects.getMuNumber());
						//出入库说明默认为批发出库
						kcmx.setSrExplain("批发出库");
						//是否有效默认为1
						kcmx.setIsva(1);
						//操作时间默认为date设置进去
						kcmx.setOpenTime(date);
						//判断获取到的session user不等于空
						if(user!=null) {
						//从session里获取用户名设置进库存明细操作人里
						kcmx.setOper(user.getBuName());
						}
						//库存明细排序默认为1
						kcmx.setSort("1");
						//调用库存明细service 增加查询放入库存明细类对象
						int insertSelective = stockRecordService.insertSelective(kcmx);
						System.err.println("  增加库存明细记录返回的值："+insertSelective);
						}
						
						
					 
					
				}
			}
			
			/**
			  * 增加财务的方法
			 */
			//调用根据批发id查询所有放入批发类对象并返回批发模型类对象的的方法 
			ListenBranchWholesale bwIdselectAll = wholesaleService.bwIdselectAll(wholesale);
			//用工具类判断返回过来的对象里公司id不为空
			if(!Tools.isEmpty(bwIdselectAll.getCompanyId())) {
				//定义一个map对象mapCw
				Map<String, Object> mapCw=new HashMap<>();
				//使用对象获取对象里的分店销售总金额，键为cw
				mapCw.put("cw", bwIdselectAll.getBwPrice());
				//使用对象获取对象里的公司id，键为id
				mapCw.put("id", bwIdselectAll.getCompanyId());
				System.err.println(" 根据id查询所有的方法公司的值  ："+bwIdselectAll.getCompanyId()+" 批发总金额"+bwIdselectAll.getBwPrice());
				System.err.println("长度"+mapCw.size());
				//调用财务service 根据id修改财务 返回int的方法
				 idUpdateCw = financeService.idUpdateCw(mapCw);
				System.err.println("调用根据id修改财务返回的值   :"+idUpdateCw);
			}
			//调用根据批发id查询财务id 返回类对象的方法
			ListenBranchWholesale bwidSelectCwId = wholesaleService.bwidSelectCwId(wholesale);
			System.err.println(" 判断返回过来的财务id不为空的值 :"+bwidSelectCwId.getFinanceId());
			//用工具类判断返回过来的财务id不为空
			if(!Tools.isEmpty(bwidSelectCwId.getFinanceId())){
				System.err.println(" 判断返回过来的财务id不为空进来了 :"+bwidSelectCwId.getFinanceId());
				//获取财务明细模型类对象
				ListenFinanceDetail cwmx=new ListenFinanceDetail();
				//用工具类获取三十位的uuid
				String uuid=Tools.getRandomString(30);
				//把获取到的uuid设置进财务明细id里
				cwmx.setFdId(uuid);
				//把获取的财务id设置进财务明细外键财务里
				cwmx.setFinanceId(bwidSelectCwId.getFinanceId());
				//获取时间类对象date
				Date date=new Date();
				//把date对象设置进财务时间里
				cwmx.setFdTime(date);
				//把获取到的批发销售总价钱设置进财务金额里
				cwmx.setFdPrice(bwIdselectAll.getBwPrice());
				//把获取到的批发id从对象里取出设置进财务明细业务id里
				cwmx.setVocationalWorkId(bwIdselectAll.getBwId());
				//把获取到的销售总数量从模型类取出设置进财务数量里
				cwmx.setFdNumber(bwIdselectAll.getBwNumber());
				//财务明细是否有效默认为1设置进去
				cwmx.setIsva(1);
				//财务明细操作时间默认设置date对象进去
				cwmx.setOpenTime(date);
				//判断session获取的user对象不等于空
				if(user!=null) {
				//把用户名从user中取出设置进模型类操作人里
				cwmx.setOper(user.getBuName());
				}
				//财务明细记录sort默认设置为 收入，公司批发
				cwmx.setSort("收入，分公司批发");
				//支出类型默认为4设置进财务明细里
				cwmx.setSpendingtype(4);
				//使用财务service 调用增加查询返回int的方法
				int insertSelective = financeDetailService.insertSelective(cwmx);
				System.out.println("  调用增加财务记录明细返回int的int值："+insertSelective);
			}
			
		}
		//获取jsonMsg工具类
		JsonMsg msg=new JsonMsg();
		//判断库存修改和财务修改返回接受的值大于零
		if(muIdUpdate>0 && idUpdateCw>0) {
			//datas设置为1
			msg.setDatas(1);
			//msg设置为操作成功
			msg.setMsg("操作成功");
		}else {
			//datas设置为0
			msg.setDatas(0);
			//msg设置为操作失败
			msg.setMsg("操作失败");
		}
		//返回msg对象
		return msg;
		}
}